package sanrenxing.statu.dao.impl;

import sanrenxing.statu.dao.StatuDao;
import sanrenxing.statu.domain.Statu;
import sanrenxing.statu.domain.StatuTo;
import sanrenxing.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * 功能:考生状态
 * 编写者:黄雄珠
 * 创建时间：2020/9/27 16:36
 * 版本:1.0
 */
public class StatuDaoImpl implements StatuDao {
    /**
     * 根据编号主键从数据库Statu表中删除指定数据
     * @param conditionId 编号主键
     * @return 删除影响的行数(1 : 删除成功 ; 0 : 删除失败)
     */
    @Override
    public int delete(int conditionId) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //定义影响行数的变量
        int rows=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL 删除语句字符串 外加条件状态编号conditionId
            String sql="delete from statu where conditionId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,conditionId);
            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows=pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     * 根据编号主键从数据库Statu表中查找单个
     *
     * @param conditionId 编号主键
     * @return 对象(如果返回null值 ， 表示查找失败)
     */
    @Override
    public Statu findById(int conditionId) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的考生状态对象
        Statu statu=null;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL查询语句字符串 状态编号conditionId ，学员编号，班级编号，试卷编号paperId，状态conditions  外加条件状态编号
            String sql="select conditionId,stuId,classId,paperId,conditions from emp where conditionId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,conditionId);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //判断结果集，并把结果集的数据封装到考生状态对象中
            if(rs.next()){
                //实例化考生状态对象
                statu=new Statu();
                //把结果集数据赋值给考生状态对象各属性
                statu.setConditionId(rs.getInt("conditionId"));
                statu.setStuId(rs.getString("stuId"));
                statu.setClassId(rs.getInt("classId"));
                statu.setPaperId(rs.getInt("paperId"));
                statu.setConditions(rs.getString("conditions"));
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回考生状态对象
        return statu;
    }

    /**
     * Statu 考生状态对象
     *
     * @return 考生状态对象集合
     */
    @Override
    public List<Statu> findAll() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的考生状态对象集合
        List<Statu> statuList=new ArrayList<Statu>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL 查询语句字符串 字段有状态编号conditionId ，学员编号，班级编号，试卷编号paperId，状态conditions
            String sql="select conditionId,stuId,classId,paperId,conditions from statu";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到考生状态对象中
            while(rs.next()){
                //定义考生状态对象
                Statu statu=new Statu();
                //把结果集数据赋值给考生状态对象各属性
                statu.setConditionId(rs.getInt("conditionId"));
                statu.setStuId(rs.getString("stuId"));
                statu.setClassId(rs.getInt("classId"));
                statu.setPaperId(rs.getInt("paperId"));
                statu.setConditions(rs.getString("conditions"));
                //把考生状态对象添加考生状态集合中
                statuList.add(statu);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回考生状态对象集合
        return statuList;
    }

    /**
     * 从数据库statu表中查询指定页的考生状态对象集合
     *
     * @param rows  每页的考生状态行数
     * @param pages 页数
     * @return 当前页的考生状态对象集合
     */
    @Override
    public List<Statu> findByPage(int rows, int pages) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的考生状态对象集合
        List<Statu> statuList=new ArrayList<Statu>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL查询语句字符串 字段名有状态编号conditionId ，学员编号，班级编号，试卷编号paperId，状态conditions  statu limit？？
            String sql="select conditionId,stuId,classId,paperId,conditions from statu limit ?,?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给分页语句占位符赋值
            //分页语句：select * from 表名 limits (pages-1)*rows,rows
            pstmt.setInt(1,(pages-1)*rows);
            pstmt.setInt(2,rows);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到考生状态对象中
            while(rs.next()){
                //定义考生状态对象
                Statu statu=new Statu();
                //把结果集数据赋值给考生状态对象各属性
                statu.setConditionId(rs.getInt("conditionId"));
                statu.setStuId(rs.getString("stuId"));
                statu.setClassId(rs.getInt("classId"));
                statu.setPaperId(rs.getInt("paperId"));
                statu.setConditions(rs.getString("conditions"));
                //把考生状态对象添加考生状态集合中
                statuList.add(statu);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回考生状态对象集合
        return statuList;
    }

    /**
     * 统计数据库statu表中记录总数
     *
     * @return 考生状态表中记录总数
     */
    @Override
    public int count() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回表中总数据行数rowCount
        int rowCount=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL 查询语句字符串 统计statu总行数 取名为as statucount
            String sql="select count(*) as statucount from statu";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集合
            rs=pstmt.executeQuery();
            //判断结果集，并获得总行数
            if(rs.next()){
                //把结果集中的总行数赋值给定义的rowCount
                rowCount=rs.getInt("statucount");
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回表中数据总行数
        return rowCount;
    }

    /**
     * 条件分页查询
     *
     * @param rows      每页行数
     * @param pages     页数
     * @param condition 条件
     * @return 考生状态对象集合
     */
    @Override
    public List<StatuTo> findByPage(int rows, int pages, String condition) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的考生状态对象集合StatuTo
        List<StatuTo> statuToList=new ArrayList<StatuTo>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL查询语句字符串 连接学员表student为stu 连接条件stuId  连接班级表cl 条件classId 附加条件1=1 "+condition+" limit ?,?
            //字段名状态编号conditionId，学员名字stuName，班级名称className，试卷编号paperId，状态conditions
            String sql="SELECT sta.conditionId,stu.stuName,cl.className,sta.paperId,sta.conditions FROM statu sta" +
                    " JOIN student stu ON sta.stuId=stu.stuId JOIN class cl ON sta.classId=cl.classId " +
                    "where 1=1 "+condition+" limit ?,?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给分页语句占位符赋值
            //分页语句：select * from 表名 limits (pages-1)*rows,rows
            pstmt.setInt(1,(pages-1)*rows);
            pstmt.setInt(2,rows);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到考生状态对象中
            while(rs.next()){
                //定义考生状态对象
                StatuTo statuTo=new StatuTo();
                //把结果集数据赋值给考生状态对象各属性
                statuTo.setConditionId(rs.getInt("conditionId"));
                statuTo.setStuName(rs.getString("stuName"));
                statuTo.setClassName(rs.getString("className"));
                statuTo.setPaperId(rs.getInt("paperId"));
                statuTo.setConditions(rs.getString("conditions"));
                //把考生状态对象添加考生状态集合中
                statuToList.add(statuTo);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回考生状态对象集合
        return statuToList;
    }

    /**
     * 条件统计
     *
     * @param condition 条件
     * @return 数
     */
    @Override
    public int count(String condition) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回表中总数据行数rowCount
        int rowCount=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL查询语句字符串 统计statu的总行数 取名为statucount 表名statu取名为sta  条件1=1 +condition
            String sql="select count(*) as statucount from statu sta where 1=1 "+condition;
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集合
            rs=pstmt.executeQuery();
            //判断结果集，并获得总行数
            if(rs.next()){
                //把结果集中统计的总行数statucount赋值给定义好的rowCount
                rowCount=rs.getInt("statucount");
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回表中数据总行数
        return rowCount;
    }

    /**
     * 获取查询条件
     *
     * @param statu 考生状态对象
     * @return 条件字符串
     */
    @Override
    public String getCondition(Statu statu) {
        //定义查询条件字符串condition，初值为带空格的字符串(注意后续条件中的空格)“ ”
        String condition=" ";
        //如果考生状态对象为空，则直接返回空字符串return condition
        if(statu==null){
            return condition;
        }
        //如果主键编号conditionId不为空
        if(statu.getConditionId()!=0){
            condition += " and sta.conditionId="+statu.getConditionId();
        }

        //如果学号stuId不为0(字符串匹配模糊查询)
        if(statu.getStuId()!=null && statu.getStuId().trim().length()!=0){
            condition += " and sta.stuId like '%"+statu.getStuId()+"%' ";
        }
        //如果班级编号classId不为空
        if(statu.getClassId()!=0){
            condition += " and sta.classId="+statu.getClassId();
        }
        //如果试卷编号编号paperId不为空
        if(statu.getPaperId()!=0){
            condition += " and sta.paperId="+statu.getPaperId();
        }
        //如果考生状态·conditions不为0(字符串匹配模糊查询)
        if(statu.getConditions()!=null && statu.getConditions().trim().length()!=0){
            condition += " and sta.conditions like '%"+statu.getConditions()+"%' ";
        }
        //返回条件字符串
        return condition;
    }

    /**
     * 通过学员名字查询学员编号
     *
     * @param stuName
     * @return
     */
    @Override
    public String findStuId(String stuName) {
        //定义学员编号字符串
        String StuId;
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;


        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL查询语句字符串 查询学员表中的全部学员编号  条件为学员名字stuName=？
            String sql="SELECT  StuId FROM student where stuName=? ";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setString(1,stuName);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            if (rs.next()){
                //定义StuId接收结果集中的学员编号
                StuId=rs.getString("StuId");
                //返回stuId
                return StuId;
            }

        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回null
        return null;
    }

    /**
     * 通过班级名称查询班级编号
     * @param className
     * @return
     */
    @Override
    public int findClassId(String className) {
        //定义一个int类型班级Id变量
        int classId;
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;


        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL查询语句字符串 查询班级表中的全部班级编号 条件为className=？
            String sql="SELECT  classId FROM class where className=? ";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setString(1,className);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            if (rs.next()){
                //定义classId变量接收结果集中的班级编号
                classId=rs.getInt("classId");
                //返回班级编辑编号
                return classId;
            }

        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回0
        return 0;
    }

}
